// orders.js
const app = getApp()

Page({
  data: {
    orders: [],
    filteredOrders: [],
    activeTab: 'all',
    filterTabs: [],
    showDetailModal: false,
    currentOrder: {}
  },

  onLoad() {
    console.log('厨师订单管理页面加载')
    
    // 检查用户是否已登录
    if (!app.globalData.userInfo || !app.globalData.userInfo._id) {
      console.log('用户未登录，显示提示信息')
      wx.showModal({
        title: '提示',
        content: '请先登录后再使用厨师功能',
        showCancel: false,
        success: () => {
          // 返回上一页或首页
          wx.navigateBack({
            delta: 1,
            fail: () => {
              wx.switchTab({
                url: '/pages/index/index'
              })
            }
          })
        }
      })
      return
    }
    
    // 检查用户角色权限
    if (!app.isChef()) {
      console.log('用户角色权限不足，当前角色:', app.globalData.userRole)
      wx.showModal({
        title: '权限不足',
        content: '此页面仅限厨师访问',
        showCancel: false,
        success: () => {
          wx.navigateBack({
            delta: 1,
            fail: () => {
              wx.switchTab({
                url: '/pages/index/index'
              })
            }
          })
        }
      })
      return
    }
    
    console.log('用户已登录且具有厨师权限，开始加载订单数据')
    this.loadOrders()
    
    // 设置定时刷新，每5秒检查一次新数据
    this.refreshTimer = setInterval(() => {
      console.log('定时检查订单数据更新...')
      this.loadOrders()
    }, 5000) // 5秒
    
    // 设置事件监听
    this.setupEventListeners()
  },

  onShow() {
    console.log('厨师订单管理页面显示')
    
    // 检查是否需要刷新订单统计
    if (app.globalData.needRefreshChefOrderStats) {
      console.log('检测到需要刷新厨师订单统计，开始刷新...')
      app.globalData.needRefreshChefOrderStats = false
      this.loadOrders()
    } else {
      this.loadOrders()
    }
  },

  onUnload() {
    // 页面卸载时清除定时器
    if (this.refreshTimer) {
      clearInterval(this.refreshTimer)
      this.refreshTimer = null
      console.log('厨师订单页面定时器已清理')
    }
    
    // 清理事件监听
    this.cleanupEventListeners()
  },

  // 加载订单数据
  async loadOrders() {
    try {
      // 检查用户是否已登录
      if (app.globalData.userInfo && app.globalData.userInfo._id) {
        console.log('厨师用户已登录，从云数据库加载所有家庭订单数据')
        
        // 厨师需要看到所有家庭订单，直接从云数据库获取
        const { orderService } = require('../../../utils/cloud.js')
        const result = await orderService.getFamilyOrders('xiaoweichufang')
        
        if (result.success) {
          const allOrders = result.data || []
          console.log('从云数据库获取的所有家庭订单:', allOrders)
          console.log('订单总数:', allOrders.length)
          
          // 预处理订单数据，确保时间格式正确
          const processedOrders = allOrders.map(order => {
            console.log('处理订单:', order._id, 'createTime:', order.createTime, '类型:', typeof order.createTime)
            console.log('订单完整数据:', order)
            
            // 确保createTime是正确格式
            if (order.createTime) {
              // 如果createTime是Date对象，转换为字符串
              if (order.createTime instanceof Date) {
                order.createTime = order.createTime.toLocaleString('zh-CN', {
                  year: 'numeric',
                  month: '2-digit',
                  day: '2-digit',
                  hour: '2-digit',
                  minute: '2-digit'
                })
                console.log('Date对象转换后:', order.createTime)
              }
              // 如果createTime是时间戳，转换为字符串
              else if (typeof order.createTime === 'number') {
                order.createTime = new Date(order.createTime).toLocaleString('zh-CN', {
                  year: 'numeric',
                  month: '2-digit',
                  day: '2-digit',
                  hour: '2-digit',
                  minute: '2-digit'
                })
                console.log('时间戳转换后:', order.createTime)
              }
              // 如果是字符串，检查是否为空
              else if (typeof order.createTime === 'string') {
                console.log('字符串类型:', order.createTime)
                if (!order.createTime.trim()) {
                  order.createTime = '未知时间'
                  console.log('空字符串，设置为未知时间')
                }
              }
            } else {
              console.log('createTime为空，设置为默认时间')
              order.createTime = '未知时间'
            }
            
            // 添加用户昵称显示
            if (order.userNickname) {
              order.userNickname = order.userNickname
            } else {
              order.userNickname = '未知用户'
            }
            
            console.log('最终处理结果:', order.createTime, 'userNickname:', order.userNickname)
            return order
          })
          
          console.log('处理后的所有家庭订单数据:', processedOrders)
          
          this.setData({ orders: processedOrders })
          this.updateFilterTabs()
          this.filterOrders()
          
          console.log('厨师订单管理数据加载完成，共', processedOrders.length, '个订单')
        } else {
          console.error('从云数据库加载订单失败:', result.error)
          wx.showToast({ title: '加载订单失败', icon: 'error' })
        }
      } else {
        console.log('用户未登录，使用本地数据')
        const orders = app.globalData.orders || []
        this.setData({ orders })
        this.updateFilterTabs()
        this.filterOrders()
      }
    } catch (error) {
      console.error('加载订单数据失败:', error)
      wx.showToast({ title: '加载订单失败', icon: 'error' })
    }
  },

  // 更新筛选标签
  updateFilterTabs() {
    const { orders } = this.data
    const totalOrders = orders.length
    const pendingOrders = orders.filter(order => order.status === 'pending').length
    const cookingOrders = orders.filter(order => order.status === 'cooking').length
    const completedOrders = orders.filter(order => order.status === 'completed').length
    const rejectedOrders = orders.filter(order => order.status === 'rejected').length
    
    const filterTabs = [
      { key: 'all', name: '全部', count: totalOrders },
      { key: 'pending', name: '待处理', count: pendingOrders },
      { key: 'cooking', name: '制作中', count: cookingOrders },
      { key: 'completed', name: '已完成', count: completedOrders },
      { key: 'rejected', name: '已拒绝', count: rejectedOrders }
    ]

    this.setData({ filterTabs })
  },

  // 切换筛选标签
  switchTab(e) {
    const key = e.currentTarget.dataset.key
    this.setData({ activeTab: key })
    this.filterOrders()
  },

  // 筛选订单
  filterOrders() {
    const { orders, activeTab } = this.data
    let filteredOrders = []

    if (activeTab === 'all') {
      filteredOrders = orders
    } else {
      filteredOrders = orders.filter(order => order.status === activeTab)
    }

    // 按时间倒序排列
    filteredOrders.sort((a, b) => {
      if (!a.createTime || !b.createTime) return 0
      const dateA = new Date(a.createTime)
      const dateB = new Date(b.createTime)
      if (isNaN(dateA.getTime()) || isNaN(dateB.getTime())) return 0
      return dateB - dateA
    })

    this.setData({ filteredOrders })
  },

  // 获取当前标签名称
  getActiveTabName() {
    const { filterTabs, activeTab } = this.data
    const currentTab = filterTabs.find(tab => tab.key === activeTab)
    return currentTab ? currentTab.name : '全部'
  },

  // 获取状态文本
  getStatusText(status) {
    const statusMap = {
      'pending': '待处理',
      'cooking': '制作中',
      'completed': '已完成',
      'cancelled': '已取消',
      'rejected': '已拒绝'
    }
    return statusMap[status] || status
  },

  // 获取订单时间
  getOrderTime(order) {
    console.log('=== getOrderTime 开始 ===')
    console.log('传入的订单对象:', order)
    console.log('订单对象的类型:', typeof order)
    console.log('订单对象的所有键:', Object.keys(order))
    
    // 尝试多种可能的时间字段名
    const timeFields = ['createTime', 'createdAt', 'time', 'orderTime', 'date', 'timestamp']
    
    for (const field of timeFields) {
      console.log(`检查字段 ${field}:`, order[field])
      if (order[field]) {
        console.log(`找到时间字段 ${field}:`, order[field], '类型:', typeof order[field])
        
        // 如果已经是Date对象，直接返回
        if (order[field] instanceof Date) {
          console.log(`字段 ${field} 是Date对象，直接返回`)
          // 直接在这里格式化时间并返回
          return this.formatTime(order[field])
        }
        
        // 如果是字符串，尝试解析
        if (typeof order[field] === 'string') {
          console.log(`字段 ${field} 是字符串，返回字符串`)
          return this.formatTime(order[field])
        }
        
        // 如果是数字（时间戳），转换为Date对象
        if (typeof order[field] === 'number') {
          console.log(`字段 ${field} 是数字，转换为Date对象`)
          return this.formatTime(new Date(order[field]))
        }
        
        // 如果是对象，尝试提取时间信息
        if (typeof order[field] === 'object' && order[field] !== null) {
          console.log(`字段 ${field} 是对象，尝试提取时间信息:`, order[field])
          
          // 尝试常见的对象时间字段
          const objTimeFields = ['$date', 'value', 'time', 'timestamp', 'date']
          for (const objField of objTimeFields) {
            if (order[field][objField]) {
              console.log(`在对象中找到时间字段 ${objField}:`, order[field][objField])
              return this.formatTime(order[field][objField])
            }
          }
          
          // 如果对象有toString方法，尝试转换
          if (order[field].toString && order[field].toString !== Object.prototype.toString) {
            const strValue = order[field].toString()
            console.log(`对象toString结果:`, strValue)
            if (strValue !== '[object Object]') {
              return this.formatTime(strValue)
            }
          }
        }
      }
    }
    
    console.log('未找到任何时间字段')
    console.log('=== getOrderTime 结束 ===')
    return '时间未知'
  },

  // 组合函数：获取并格式化订单时间
  getFormattedOrderTime(order) {
    console.log('🔥🔥🔥 getFormattedOrderTime 函数被调用了！🔥🔥🔥')
    const time = this.getOrderTime(order)
    return this.formatTime(time)
  },

  // 格式化时间显示
  formatTime(timeInput) {
    console.log('🔥🔥🔥 formatTime 函数被调用了！🔥🔥🔥')
    console.log('=== formatTime 开始 ===')
    console.log('传入的时间输入:', timeInput)
    console.log('时间输入的类型:', typeof timeInput)
    console.log('时间输入是否为Date对象:', timeInput instanceof Date)
    
    if (!timeInput) {
      console.log('时间输入为空，返回默认值')
      console.log('=== formatTime 结束 ===')
      return '时间未知'
    }
    
    try {
      let date
      
      // 如果已经是Date对象，直接使用
      if (timeInput instanceof Date) {
        date = timeInput
        console.log('输入已经是Date对象:', date)
      } else {
        // 否则尝试创建Date对象
        date = new Date(timeInput)
        console.log('解析后的日期对象:', date)
      }
      
      if (isNaN(date.getTime())) {
        console.log('日期解析失败，返回原始字符串')
        console.log('=== formatTime 结束 ===')
        return String(timeInput) // 如果解析失败，返回原始值的字符串形式
      }
      
      const now = new Date()
      const diff = now - date
      const oneDay = 24 * 60 * 60 * 1000
      
      console.log('当前时间:', now)
      console.log('订单时间:', date)
      console.log('时间差(毫秒):', diff)
      console.log('一天毫秒数:', oneDay)
      
      let result
      if (diff < oneDay) {
        // 今天
        result = date.toLocaleTimeString('zh-CN', { 
          hour: '2-digit', 
          minute: '2-digit',
          hour12: false 
        })
        console.log('判断为今天，显示时间')
      } else if (diff < 2 * oneDay) {
        // 昨天
        result = '昨天 ' + date.toLocaleTimeString('zh-CN', { 
          hour: '2-digit', 
          minute: '2-digit',
          hour12: false 
        })
        console.log('判断为昨天，显示昨天+时间')
      } else {
        // 其他日期
        result = date.toLocaleDateString('zh-CN', { 
          month: '2-digit', 
          day: '2-digit',
          hour: '2-digit', 
          minute: '2-digit',
          hour12: false 
        })
        console.log('判断为其他日期，显示完整日期时间')
      }
      
      console.log('格式化后的时间结果:', result)
      console.log('=== formatTime 结束 ===')
      return result
    } catch (error) {
      console.error('时间格式化失败:', error)
      console.log('=== formatTime 结束(异常) ===')
      return String(timeInput)
    }
  },

  // 接单
  acceptOrder(e) {
    const orderId = e.currentTarget.dataset.id
    console.log('接单:', orderId)
    this.updateOrderStatus(orderId, 'cooking', '接单成功')
  },

  // 完成订单
  completeOrder(e) {
    const orderId = e.currentTarget.dataset.id
    console.log('完成订单:', orderId)
    this.updateOrderStatus(orderId, 'completed', '订单已完成')
  },

  // 拒绝订单
  rejectOrder(e) {
    const orderId = e.currentTarget.dataset.id
    console.log('拒绝订单:', orderId)
    wx.showModal({
      title: '确认拒绝',
      content: '确定要拒绝这个订单吗？拒绝后积分将退还给用户。',
      success: (res) => {
        if (res.confirm) {
          this.updateOrderStatus(orderId, 'rejected', '订单已拒绝')
        }
      }
    })
  },

  // 更新订单状态 - 简化版本
  async updateOrderStatus(orderId, newStatus, message) {
    try {
      console.log(`更新订单状态: ${orderId} -> ${newStatus}`)
      
      // 设置当前操作的订单信息，用于事件通知
      this.currentOrderId = orderId
      
      // 1. 更新云数据库
      const { orderService } = require('../../../utils/cloud.js')
      console.log('开始调用云数据库更新...')
      
      // 先测试云数据库连接
      try {
        const db = wx.cloud.database()
        console.log('云数据库连接正常')
        
        // 查询订单是否存在
        const orderQuery = await db.collection('orders').doc(orderId).get()
        console.log('查询订单结果:', orderQuery)
        
        if (!orderQuery.data) {
          console.error('订单不存在于云数据库:', orderId)
          wx.showToast({ title: '订单不存在', icon: 'error' })
          return
        }
        
        // 设置订单所属用户ID
        this.currentUserId = orderQuery.data.userId
        console.log('订单所属用户ID:', this.currentUserId)
        console.log('订单存在，当前状态:', orderQuery.data.status)
        
      } catch (dbError) {
        console.error('云数据库连接测试失败:', dbError)
        wx.showToast({ title: '数据库连接失败', icon: 'error' })
        return
      }
      
      const result = await orderService.updateOrderStatus(orderId, newStatus)
      console.log('云数据库更新结果:', result)
      
      if (result.success) {
        console.log('云数据库更新成功')
        
        // 2. 更新本地数据
        const orders = app.globalData.orders
        const orderIndex = orders.findIndex(order => order._id === orderId)
        
        if (orderIndex !== -1) {
          // 更新全局数据
          orders[orderIndex].status = newStatus
          app.globalData.orders = orders
          
          // 3. 更新页面数据
          const currentOrders = [...this.data.orders] // 创建副本
          const pageOrderIndex = currentOrders.findIndex(order => order._id === orderId)
          
          if (pageOrderIndex !== -1) {
            currentOrders[pageOrderIndex].status = newStatus
            
            // 4. 刷新页面
            this.setData({ orders: currentOrders })
            this.updateFilterTabs()
            this.filterOrders()
            
            console.log('页面更新完成，新状态:', newStatus)
          }
          
          // 5. 显示成功消息
          wx.showToast({ title: message, icon: 'success' })
          
          // 6. 通知其他页面
          this.notifyAllPagesRefresh()
          
          // 7. 强制刷新订单数据，确保统计正确
          console.log('强制刷新订单数据...')
          await this.loadOrders()
          
        } else {
          console.error('未找到订单:', orderId)
          wx.showToast({ title: '订单不存在', icon: 'error' })
        }
      } else {
        console.error('云数据库更新失败:', result.error)
        wx.showToast({ title: '更新失败', icon: 'error' })
      }
    } catch (error) {
      console.error('更新失败:', error)
      wx.showToast({ title: '更新失败', icon: 'error' })
    }
  },

  // 查看订单详情
  viewOrderDetail(e) {
    const orderId = e.currentTarget.dataset.id
    console.log('点击详情按钮，订单ID:', orderId)
    console.log('当前所有订单:', this.data.orders)
    
    const order = this.data.orders.find(o => o._id === orderId)
    console.log('找到的订单:', order)
    console.log('订单状态:', order ? order.status : 'undefined')
    console.log('订单完整数据:', order)
    
    if (order) {
      console.log('准备显示弹窗，订单数据:', order)
      this.setData({
        showDetailModal: true,
        currentOrder: order
      }, () => {
        console.log('弹窗状态已设置为显示，showDetailModal:', this.data.showDetailModal)
        console.log('当前订单数据:', this.data.currentOrder)
        console.log('当前订单状态:', this.data.currentOrder.status)
        console.log('getStatusText结果:', this.getStatusText(this.data.currentOrder.status))
      })
    } else {
      console.error('未找到订单:', orderId)
      wx.showToast({ title: '订单信息获取失败', icon: 'error' })
    }
  },

  // 关闭详情弹窗
  closeDetailModal() {
    this.setData({ showDetailModal: false })
  },

  // 阻止事件冒泡
  stopPropagation() {
    // 在微信小程序中，使用catchtap已经可以阻止事件冒泡
    return false
  },

  // 从详情弹窗接单
  acceptOrderFromDetail() {
    const { currentOrder } = this.data
            this.updateOrderStatus(currentOrder._id, 'cooking', '接单成功')
    this.closeDetailModal()
  },

  // 从详情弹窗完成订单
  completeOrderFromDetail() {
    const { currentOrder } = this.data
            this.updateOrderStatus(currentOrder._id, 'completed', '订单已完成')
    this.closeDetailModal()
  },

  // 刷新订单
  refreshOrders() {
    this.loadOrders()
    wx.showToast({ title: '刷新成功', icon: 'success' })
  },

  // 页面下拉刷新
  onPullDownRefresh() {
    this.loadOrders()
    wx.stopPullDownRefresh()
  },

  // 通知首页刷新订单统计
  notifyHomePageRefresh() {
    // 使用事件总线或全局状态管理来通知首页刷新
    // 这里可以通过设置一个全局标志来实现
    if (app.globalData) {
      app.globalData.needRefreshOrderStats = true
    }
  },

  // 通知其他页面刷新
  notifyAllPagesRefresh() {
    if (app.globalData) {
      // 设置刷新标志
      app.globalData.needRefreshOrderStats = true
      app.globalData.needRefreshUserOrderStats = true
      app.globalData.needRefreshChefOrderStats = true
      
      // 发送事件通知，包含订单ID和用户ID信息
      if (app.globalData.eventBus) {
        console.log('🔥 发送订单状态变化事件通知')
        app.globalData.eventBus.emit('orderStatusChanged', {
          message: '订单状态已更新',
          orderId: this.currentOrderId, // 当前操作的订单ID
          userId: this.currentUserId,   // 订单所属用户ID
          timestamp: Date.now()
        })
        console.log('🔥 事件通知已发送')
      } else {
        console.error('❌ 事件总线未初始化，无法发送事件通知')
      }
    }
  },

  // 设置事件监听
  setupEventListeners() {
    // 监听订单状态变化事件
    if (app.globalData.eventBus) {
      // 先移除可能存在的监听器，避免重复
      app.globalData.eventBus.off('orderStatusChanged', this.handleOrderStatusChange.bind(this))
      app.globalData.eventBus.on('orderStatusChanged', this.handleOrderStatusChange.bind(this))
      console.log('✅ 厨师订单页面已设置事件监听')
    } else {
      console.error('❌ 事件总线未初始化，无法设置事件监听')
      // 延迟重试
      setTimeout(() => {
        this.setupEventListeners()
      }, 500)
    }
  },

  // 清理事件监听
  cleanupEventListeners() {
    if (app.globalData.eventBus) {
      app.globalData.eventBus.off('orderStatusChanged', this.handleOrderStatusChange.bind(this))
      console.log('✅ 厨师订单页面已清理事件监听')
    }
  },

  // 处理订单状态变化事件
  handleOrderStatusChange(data) {
    console.log('厨师订单页面收到订单状态变化通知:', data)
    
    // 延迟1秒刷新，确保云数据库更新完成
    setTimeout(async () => {
      console.log('延迟刷新厨师订单数据...')
      await this.loadOrders()
    }, 1000)
    
    // 显示提示
    wx.showToast({
      title: '订单状态已更新',
      icon: 'success',
      duration: 1500
    })
  }
}) 